Benutzer:Martin Häcker/Java Kurs

2006-02-06T12:30:46Z

130.149.5.137: /* Tag 4 */

= Javakurs=
* Räume -> nicht so das problem
* Beamer / VNC-Multicast?
* Zedat (FU) hat spezielle Räume für sowas?
* Anzahl der Leute: eher viel zu viele, ca. 100 Geht

= Beteiligte =
Wer kennt noch jemanden der Mitmachen würde? '''Bitte ansprechen - immer Persönlich.'''

Wir suchen Helfer die:
* den Teilnehmern bei den Java-Programmen zu helfen (wie geht das mit dem "if-then-else", der "for"-Schleife, wie schreibt man das "try-catch", ...)
* die 10 Leuten erklären wie man mit mit Java im Detail umgeht und Fragen beantworten
* die vor 100 Leuten einen Vortrag halten und Java erklären
* die helfen diese Vorträge inhaltlich Vorzubereiten

Teilnehmer bitte mit e-mail-Adresse eintragen

==Tutoren ==
* Marcel
* Martin
* Arthur
* Florian
* Thomas
* Felix

== Rechnerbetreuer ==
* Jacob
* Karl
* Andreas Janson (vielleicht)

== Teilnehmer ==
* Max

= Durchführung =
* JAVA Grundlagen!
* "Objekt" ist nicht bäh...

== Arthurs Zeitplan ==
erstmal der allgemeine Tagesablauf:

* 1 h "Großgruppe"
* 2-3 h Kleingruppe
* Pause (Essen)
* 1 h "Großgruppe"
* 2-3 h Kleingruppe
* Hausaufgaben?

daraus ergibt sich bei 4-5 Tagen 8-10 Lerneinheiten (LE).

;LE1
:Ziel eigenes "Hello World" in Java
;LE2
:Ziel Bedingung benutzen
;LE3
:Ziel Schleifen benutzen
;LE4
:Ziel Methoden Aufruf (einfach)
;LE5
:Ziel Parameter und Rückgabewerte bei Methoden
;LE6
:Ziel Objekt als Sammlung von Daten (Struct)
:Konstruktor?
;LE7
:Ziel Objekt mit Methode(n) / Konstruktor
;LE8
:Ziel Standardmethoden (toString?)
;LE9
:Ziel Standardbibliothek (z.B. file IO)
;LE10
:Ziel Standardbibliothek

* Java
** datentypen
** variablen
** zuweisung
** vergleich
** bedingungen if
** schleifen
** ein/ausgabe
** datei ein/ausgabe
* Programmieren im allgemeinen / "prozedural" programmieren
** Zustandsmaschine
* Problemlösungsstrategien
** Java
*** Debugging
*** kleine probleme
*** testen
** idee
*** kleine probleme

== Felixs Zeitplan ==
== Martins Zeitplan ==
Vorgehen nach Ausdrucksmodell? Also Sprachfeatures so einführen wie man sie braucht um Probleme ausdrücken zu können? -- Schwierig, behalte ich aber mal im Hinterkopf.

=== Tag 1 ===
Einführung nach [http://mitpress.mit.edu/sicp/full-text/book/book-Z-H-9.html#%25_chap_1 SICP Kapitel 1] (bis "Programming in Lisp")

Drei Dinge die Wichtig sind für Programmierer:
* Primitive Ausdrücke
* Kombinationsmöglichkeiten
* Abstraktionsmöglichkeiten

Java Stoff:
Ein Beispiel bringen und daran erklären was primitive Ausdrücke, Kombinationen und Abstraktionsmöglichkeiten sind (evtl. langsam entwickeln):
class Test {
static void print(double aNumber) {
System.out.println("> " + aNumber);
}

public static void main(String [] arguments) {
print(3 * 4);
print(7 + 23 * 8 - 3);
// ....
}
}
* Variablendeklaration - Namen vergeben für dinge die man berechnet hat!
** Lokale Namen und wieso: (vielleicht?) [http://mitpress.mit.edu/sicp/full-text/book/book-Z-H-4.html#%25_toc_%25_sec_Temp_41]
An dieser Stelle primitive Datentypen und String einführen, mit dem Hinweis das bei den Primitiven alles normal sei, während bei String "alles anders" ist. Dann später diesen Unterschied aufgreifen. (String ist ja nun "immutable", trotzdem?).
* Zuweisung
* if, else
* methoden -> Wichtigkeit das man Programme in verständliche und Sinnvolle Teile unterteilt: [http://mitpress.mit.edu/sicp/full-text/book/book-Z-H-10.html#%25_sec_1.1.8 Procedures as Black-Box Abstractions]
* Return
* System.out.println()
* wie testet man ob und wie etwas geht? (Java Ausprobieren)

Abstrakter Gedanke: Für den Computer ists wurscht wie man das was man meint aufschreibt, wir Menschen dagegen sind von sowaas verwirrt:
class _{static long _
(long __,long ___) {
return __==0 ?___+ 1:
___==0?_(__-1,1):_(__
-1,_(__, ___-1)) ; }
static {int _=2 ,___
= 2;System.out.print(
"a("+_+','+___+ ")="+
_ (_, ___) ) ;System
.exit(1);}}//(C) Ulli

Wir können uns aber helfen indem wir das so schreiben:
/** @see: http://de.wikipedia.org/wiki/Ackermann-Funktion */
class AckermannFunctionDemo {
static long ackermann(long n, long m) {
if (n == 0) {
return m + 1;
}
else if (m == 0) {
return ackermann(n - 1, 1)
}
else {
return ackermann(n - 1, ackermann(n, m - 1));
}
}
static {
int n = 2, m = 2;
System.out.print("ackermann(" + n + ',' + m + ") = "
+ ackermann(n, m));
System.exit(1);
}
}//(C) Ulli

Beispiele + Übungen
* Einige Expressions angeben und die Teilnehmer sollen feststellen was die ausgeben/berechnen würden
* Das gleiche dann nochmal mit if/else
* Einen mathematischen Ausdruck in Java übersetzen
* methoden definieren die bestimmte eigenschaften haben
Beispiele dann Abtippen und ausprobieren -> Sie sollen Nachfragen wenn sie was anderes hatten (oder sowas)
// TODO: Reicht das, oder brauchts noch mehr?

=== Tag 2 ===
* Methoden als abstraktionsmöglichkeiten -> verstecken von methoden [http://mitpress.mit.edu/sicp/full-text/book/book-Z-H-4.html#%25_toc_%25_sec_Temp_43] Bringts das an der stelle?
* while, for
** Anwendung davon
* Konzept Klassenbibliothek
** Javadocs finden, lesen, verwenden, schreiben -> http://www.javadocs.org
** List, ArrayList, InputReader, BufferedReader, Scanner
* Wie entwickelt man Programme stück für stück? (Vorgehen + Testen)
** kleine stücke
** seperat testen (von main aus)
** ausblick automatisieren

=== Tag 3 ===
* Objekte als daten mit methoden ausssenherum
** um innendrinn auswechseln zu können
* Objekte, Static nicht static
** [http://mitpress.mit.edu/sicp/full-text/book/book-Z-H-4.html#%25_toc_%25_sec_3.1.2 Benefits of Local State]

=== Tag 4 ===
* vorgehen
* debugging
* testen?
* Aufgaben
** Selber ein schlechtes Programm "fehlerbeseitigen lassen"
** schlechte Bezeichnungen durch bessere ersetzen lassen

= Vorgehen =
* Kochrezept....
* Legen immer main -> instanz -> run an, ohne zu verstehen
* Von Opal ausgehen -> bringt nichts weil Opal nicht verstanden?
* Von woanders ausgehen? Von null -> normale Welt
* Von vornherein Objektorientiert -> Langfristig besser? Auch kurzfristig besser?
** Test: Wird das zum Problem wenn wir das mit run() einführen?

== Was können sie wenn wir fertig sind? ==
* Utility Objekt: readFile(aFilename), getUserInput(aPrompt)
** JavaAPI lesen
** Streams verschachteln
** UtilityObjekt -> Reuse
* Objekt / null / Initialisieren
* main -> instanz -> run() (erklären wir später)?
* Programm mit mehreren Dateien
* sehen das das scheiße ist:
class _{static long _
(long __,long  ___) {
return __==0 ?___+ 1:
___==0?_(__-1,1):_(__
-1,_(__, ___-1)) ;  }
static  {int _=2 ,___
= 2;System.out.print(
"a("+_+','+___+ ")="+
_ (_,  ___) ) ;System
.exit(1);}}//(C) Ulli
* Lösungsstrategien Top->Down, Bottom->Up
** Aufgaben angehen
** Fehlerlösungsstrategien: NullPointerException, etc.
*** Was sagt denn der Fehler genau? Wie finde ich das raus?
*** Kaputter Code -> Der muss Korrigiert werden
**** n-mal das gleiche -> schleife / methode
** Zu langer code -> kurz machen
* Testen?: von main aufrufen, unittests, debuggen, printf-style
* Was wissen die Leute am Schluss von Objekten?
** Collections, Exceptions, Streams kennen
** Konstruktoren, Instanzvariablen (vielleicht weglassen?)
** Daten mit Methoden aussen herum (vielleicht)

== Sprachkonstrukte die wir Behandeln und deren Reihenfolge ==
* if
* while, for ( <- Bis hier tag eins)
* methode
* try - catch / throws??
* ++ oder +=, was noch? Oder gar nichts?
* NICHT MACHEN: try {} cach (Throwable e) {}

=== Was wir nicht machen ABSICHTLICH ===
* :?, do{}while, ++i, switch,

== Vielleicht haben wir noch Zeit hierfür? ==
* SVN?
* static / instanz -> Ebenen modell

== Erklärungsansätze ==
=== Objektorientierung ===
* Objekt, Klasse erklären als: "Klasse" Mensch
** davon dann klonen mit bestimmten Modifikationen (augenfarbe, größe, name....)
** das wäre dann klasse, objekte und konstruktoraufruf
* Objekte / Klassen erklären als
** Platonische Ideen (Pferd)
** Tatsächliches Ding (Bruno auf dem ich jeden Dienstag in Hellersdorf reite)
* Objekte als Daten mit ''Schutzschicht'' Methoden aussen herum
** Klassen als solches erst später (quasi erst prototyp und dann klassen erklären)

* Ganz anderer Ansatz: Erklären über Einheiten die sich über Nachrichten gegenseitig verständigen

=== main ===
* Sich selbst am Schopf aus dem Sumpf herausziehen -> Münchhausen
** Am anfang gibts keine Objekte, also brauchts mechanismus um das erste erstellen zu können

== Mehrere Möglichkeiten ein Programm anzufangen ==
* Eclipse Scrapbook Page (File>New>Other>Java>Java Run/Debug>Scrapbook Page)
** geeignet für: Primitive, Zusammengesetzte ausdrücke, variablen, methoden aufrufen
** evtl, sogar main motivieren, indem man erst keinen startpunkt hat und ihn dann von scrapbook nach main migriert
* Static block in der Klassse ''System.exit(0)'' nicht vergessen!
** geeignet für gar nichts?
* Code direkt in main
** startpunkt des programms
* von main aus run() aufrufen
** so wie es in ernsthaften programmen gemacht wird.

= Aufgaben die wir Stellen =
* UtilityObjekt mit readFile(aFilename) und getUserInput(aPrompt) [http://www.cs.princeton.edu/introcs/22inout/In.java.html sowas sollte rauskommen!]
* Menü Objekt, das sich leicht adaptieren lässt?
* Apfelbaum
while (apfelbaumHatNochÄpfel) {
pflückEinenApfelUndEssIhn();
}
* Collections, Polymorphie (Apfel mit Wurm....)
* [http://www.cs.princeton.edu/introcs/11hello/ Beispiele für Anfängeraufgaben]

FreitagsrundenWiki - Benutzerbeiträge [de]

Benutzer:Martin Häcker/Java Kurs